Error_State.c

Go to the documentation of this file.

#include "derivative.h"
#include "Compile_Options.h"
#include "Error_State.h"
#include "SM.h"
#include "HAL.h"
#include "SBC_AL.h"
#include "Central_Accel_AL.h"
#include "MailScheduler.h"
#include "Application_Globals.h"
#include "SIU.h"
#include "Init_State.h"
#ifdef USE_LABVIEW
#include "Labview.h"
#endif
/*
 ******************************************************************************
 * Constants
 ******************************************************************************
 */
static const uint16_t cau16PreErrorValidStates[] =
{
  SM_STATE_SETUP, SM_STATE_ERROR, SM_APPLICATION_START, SM_STATE_DECISION,
  SM_STATE_DEPLOYMENT, SM_STATE_SYSTEM_TEST, SM_STATE_GUI };
static uint32_t (* const u32pfnErrorTreatment[])(void) =
{
  &u32fnSMInitError, &u32fnStateErrorError, &u32fnStateAcquisitionError,
  &u32fnStateDecisionError, &u32fnStateDeploymentError,
  &u32fnStateSystemTestError, &u32fnStateGUIError };
#ifdef USE_LABVIEW
static const uint8_t cau8ErrorGUIMsg01[] = "Catastrophic error. Safe mode entered.";
static const uint8_t cau8ErrorGUIMsg02[] = "An error occurred. Some functionality may have been lost.";
#endif
/*
 ******************************************************************************
 * Globals
 ******************************************************************************
 */
/*
 ******************************************************************************
 * u32fnStateError
 ******************************************************************************
 */
uint32_t u32fnStateError(void)
{
  uint32_t u32Status;
  
  /* Verify that we can execute - Previous state ended correctly */
  u32Status = u32fnSMValidateCurrentState((uint16_t*)cau16PreErrorValidStates,
                                          N_ELEMENTS(cau16PreErrorValidStates));
  if(CLEAR == u32Status)
  {
    /* Here comes the real contents of the state */
    LOCK_STATE_EXECUTION();
    
    /* We will behave differently depending on the error flags and what */
    /* caused them, but there are some general cases, as shown below    */
    if(gu32SMStateStatus & (SM_INVALID_SOURCE_STATE))
    {
      /* Catastrophic failure, stop everything */
      u32Status = u32fnSafeMode();
    }
    else
    {
      /* Treat errors according to different conditions */
      u32Status = u32pfnErrorTreatment[gu16SMCurrentState[SM_PREVIOUS_STATE]]();
    }
  }
  else
  {
    /* Leave */
  }

  /* Set the next state */
  if(CLEAR != u32Status)
  {
    vfnSMWriteNextState(SM_STATE_ERROR);
  }
  else
  {
    /* We assume that each sub-routine has pointed to the next state */
#ifdef USE_LABVIEW
    /* If we've made it this far, we are going back to the application. Signal the GUI */
    vfnDisplayGUIErrorMessage();
#endif
  }
  
  /* Unlock the state */
  UNLOCK_STATE_EXECUTION();
  
  return (u32Status);
}
/*
 ******************************************************************************
 * u32fnSafeMode
 ******************************************************************************
 */
static uint32_t u32fnSafeMode(void)
{
  uint32_t u32Status;
  uint16_t u16InputPinBehavior;
  
#ifdef USE_LABVIEW
  vfnLVEnable(TRUE);
  (void)u8fnLVWaitForTxPort();
  (void)u8fnLabViewSendMSorMP((uint8_t*)&cau8ErrorGUIMsg01, sizeof(cau8ErrorGUIMsg01),
                              LV_SEND_SERIALLY, LV_MP_MSG);
#endif  
  
  /* EN_FL must never go high by accident. Make it an input. */
  u16InputPinBehavior = PIN_GPI_DEFAULT_CONFIG;
  vfnConfigDefaultPinBehavior((const uint16_t*)&u16InputPinBehavior,
                              u8fnReturnPinIndex(PIN_EN_FL), TRUE);
  
  /* Disarm all squibs  */

  /* Stop WD1 signal to CG147 */

  /* Stop scheduler (and with it, all automatic watch-dog updates) */
  (void)u8fnLaunchScheduler(CLEAR);
  
  /* Go into STOP mode */
//  vfnEnterLowPowerMode();
  
  for(;;)
  {
    /* We are not going anywhere */
  }
  return (u32Status);
}
/*
 ******************************************************************************
 * u32fnSMInitError
 ******************************************************************************
 */
static uint32_t u32fnSMInitError(void)
{
  uint32_t u32Status;
  uint8_t u8Counter1;
  uint8_t u8Counter2;
  uint32_t u32Mask;
  
  /* Init local variables */
  u32Status = CLEAR;
  u8Counter1 = CLEAR;
  
  /* Trap the cases where we should not go anywhere. */
  if(gu32SMStateStatus & (INIT_STATE_CA_ERROR | INIT_STATE_MCU_ERROR
      | INIT_STATE_SBC_ERROR))
  {
    u32Status = u32fnSafeMode();
  }
  else
  {
    /* Turn the lamp on */
    (void)u8fnSBCEnableWarningLamp(TRUE);
    
    /* These situations should allow for partial behavior of our system */
    if(gu32SMStateStatus & SBC_TEST_ALL_SAT)
    {
      /* SATELLITE PROBLEM */
      /* Remove the satellite from the active satellite list */
      gu16ActivePSI5Channels
          = u16fnErrorRemoveFromList(gu16ActivePSI5Channels,
                                     (uint16_t)gu32SMStateStatus);
      /* And remove the associated squibs as well */
      for(u32Mask = BIT0; u32Mask < BIT12; u32Mask <<= BIT0)
      {
        if(gu32SMStateStatus & u32Mask)
        {
          for(u8Counter2 = CLEAR; u8Counter2 < cu8SizeOfSatToSquibs; u8Counter2 += 2u)
          {
            if(cau8SatToSquibs[u8Counter2] == u8Counter1)
            {
              gu16ActiveSquibChannels = u16fnErrorRemoveFromList(gu16ActiveSquibChannels,
                                         BIT0 << (cau8SatToSquibs[u8Counter2 + 1u]));
            }
            else
            {
              /* Nothing */
            }
          }
        }
        else
        {
          /* Nothing */
        }
        u8Counter1++;
      }
    }
    else
    {
      /* Nothing */
    }
    if(gu32SMStateStatus & SBC_TEST_ALL_SQUIB)
    {
      /* Squib problem */
      /* Remove the squib from the active squib list */
      gu16ActiveSquibChannels
          = u16fnErrorRemoveFromList(gu16ActiveSquibChannels,
                                     (uint16_t)(gu32SMStateStatus >> BITS_IN_16));
    }
    else
    {
      /* Nothing */
    }
    
    /* If we have no squibs or satellites, it's the end of the road for us */
    if((CLEAR == gu16ActivePSI5Channels) || (CLEAR == gu16ActiveSquibChannels))
    {
      /* Not much more left to do */
      u32Status = u32fnSafeMode();
    }
    else
    {
      /* Nothing */
    }
    
    /* Choose the next state */
    vfnSMWriteNextState(SM_APPLICATION_START);
  }
  
  return (u32Status);
}
/*
 ******************************************************************************
 * u32fnStateErrorError
 ******************************************************************************
 */
static uint32_t u32fnStateErrorError(void)
{
  uint32_t u32Status;
  
  /* We are not going anywhere. */
  u32Status = u32fnSafeMode();
  
  return (u32Status);
}
/*
 ******************************************************************************
 * u32fnStateAcquisitionError
 ******************************************************************************
 */
static uint32_t u32fnStateAcquisitionError(void)
{
  uint32_t u32Status;
  
  if(gu32SMStateStatus & STATUS_CA_FAILED)
  {
    /* We are not going anywhere. */
    u32Status = u32fnSafeMode();
  }
  else
  {
    /* Turn on the lamp */
    (void)u8fnSBCEnableWarningLamp(TRUE);
    
    /* One of the satellites or seat-buckles failed and must be disabled */
    gu16ActivePSI5Channels
        = u16fnErrorRemoveFromList(gu16ActivePSI5Channels,
                                   (uint16_t)gu32SMStateStatus);
    
    if(CLEAR == gu16ActivePSI5Channels)
    {
      /* Not much more left to do */
      u32Status = u32fnSafeMode();
    }
    else
    {
      /* Nothing */
    }
    vfnSMWriteNextState(SM_STATE_DECISION);
  }
  
  return (u32Status);
}
/*
 ******************************************************************************
 * u32fnStateDecisionError
 ******************************************************************************
 */
static uint32_t u32fnStateDecisionError(void)
{
  uint32_t u32Status;
  
  u32Status = CLEAR;
  
  /* Turn on the lamp */
  (void)u8fnSBCEnableWarningLamp(TRUE);
  
  if(gu32SMStateStatus & SBC_TEST_ALL_SAT)
  {
    /* This case should never be reached, but if it does, we should disable */
    /* the failed satellite(s)                                              */
    gu16ActivePSI5Channels
        = u16fnErrorRemoveFromList(gu16ActivePSI5Channels,
                                   (uint16_t)gu32SMStateStatus);
    if(CLEAR == gu16ActivePSI5Channels)
    {
      /* Not much more left to do */
      u32Status = u32fnSafeMode();
    }
    else
    {
      /* Nothing */
    }
  }

  vfnSMWriteNextState(SM_STATE_DEPLOYMENT);
  
  return (u32Status);
}
/*
 ******************************************************************************
 * u32fnStateDeploymentError
 ******************************************************************************
 */
static uint32_t u32fnStateDeploymentError(void)
{
  uint32_t u32Status;
  
  u32Status = CLEAR;
  
  vfnSMWriteNextState(SM_STATE_SYSTEM_TEST);
  
  /* We will come into this state if there was an inadvertent deployment, */
  /* we shall therefore go into a safe-mode.                              */
  u32Status = u32fnSafeMode();
  
  return (u32Status);
}
/*
 ******************************************************************************
 * u32fnStateSystemTestError
 ******************************************************************************
 */
static uint32_t u32fnStateSystemTestError(void)
{
  uint32_t u32Status;
  
  u32Status = CLEAR;
  
  /* To be developed by customer */
  
  vfnSMWriteNextState(SM_APPLICATION_START);
  
  return (u32Status);
}
/*
 ******************************************************************************
 * u32fnStateGUIError
 ******************************************************************************
 */
static uint32_t u32fnStateGUIError(void)
{
  
  uint32_t u32Status;
  
  u32Status = CLEAR;
  
  /* GUI state errors can be safely ignored - they're for demo purposes only */
  
  vfnSMWriteNextState(SM_APPLICATION_START);
  
  return (u32Status);
}
/*
 ******************************************************************************
 * u16fnErrorRemoveFromList
 ******************************************************************************
 */
static uint16_t u16fnErrorRemoveFromList(uint16_t u16Original, uint16_t u16Failed)
{
  u16Original &= (uint16_t)~(u16Failed & (BIT11 | BIT10
      | BIT9 | BIT8 | BIT7 | BIT6 | BIT5 | BIT4 | BIT3 | BIT2 | BIT1 | BIT0));
  return (u16Original);
}
#ifdef USE_LABVIEW
/*
 ******************************************************************************
 * vfnDisplayGUIErrorMessage
 ******************************************************************************
 */
static void vfnDisplayGUIErrorMessage(void)
{
  vfnLVEnable(TRUE);
  (void)u8fnLVWaitForTxPort();
  (void)u8fnLabViewSendMSorMP((uint8_t*)&cau8ErrorGUIMsg02, sizeof(cau8ErrorGUIMsg02),
                              LV_SEND_SERIALLY, LV_MP_MSG);
  vfnLVEnable(CLEAR);
  return;
}
#endif
/*
 ******************************************************************************
 *
 *  End of file.
 *
 ******************************************************************************
 */